package main

import (
	"fmt"
	"runtime"
	"time"
)

func m1() (int, int, int) {
	return 100, 140, 200
}

/**
 * 变量赋值
 */
func 变量赋值() {
	fmt.Println("--------------变量赋值-------------------------")
	// 赋值方式一： var 变量名 数据类型
	var age int
	age = -1

	fmt.Printf("年龄：%d \n", age)

	// var 赋值方式二  := 赋值  不能进行全局变量声明
	A := 100
	fmt.Printf("x: %d \n", A)

	// 赋值方式三: var 变量名 = 值
	var name = "张三"
	fmt.Printf("name: %s %d \n", name, len(name))

	fmt.Printf("name的内存地址为：%p \n", &name)
	fmt.Printf("name的内存地址为：%s \n", &name)

	// 赋值方式四: var 变量名1,变量名2,变量名3 = 值1,值2,值3
	var a, b, c = 1, 2, 3
	fmt.Printf("a,b,c的值为：%d,%d,%d \n", a, b, c)

	// 赋值方式五: var 占位符,占位符,变量名2 = 值1,值2,值3  匿名变量
	var _, _, d = 1, 2, 3
	fmt.Printf("d的为：%d\n", d)

	// 多返回值 赋值
	a, b, _ = m1()
	fmt.Printf("a,b的为：%d,%d\n", a, b)

	// 多变量声明
	var (
		x int = 101
		y int //默认值为0
		z float32
		k string
	)

	fmt.Printf("x默认值为 %d y默认值为 %d z默认值为 %f k默认值为 %s \n", x, y, z, k)

}

func 常量() {
	fmt.Println("--------------常量-------------------------")
	//常量不能被修改
	const name = "张三"
	//name = "张三1"
	fmt.Printf("name: %s \n", name)

	// iota必须配合const使用
	const (
		a = 100 * iota
		b
		c
		d = iota + 1
	)

	fmt.Printf("a,b,c,d的值为：%d,%d,%d,%d \n", a, b, c, d)
}

func deferCall() {
	fmt.Println("-----------deferCall---------")
}

func deferCall2() {
	fmt.Println("-----------deferCall2---------")
}

func returnCall() int {
	fmt.Println("-----------returnCall---------")
	return 0
}

/**
 * 关键字defer
 */
func deferMethod() int {
	// return后执行defer,defer先进入栈，后出栈，先执行后入栈的defer方法
	defer deferCall()
	defer deferCall2()

	return returnCall()
}

func 匿名函数() {
	fmt.Println("进入了函数体")

	func() {
		// 退出整个函数
		runtime.Goexit() //必须配合协程一起使用
		fmt.Println("匿名函数")
	}()

	func(a int) {
		fmt.Println("匿名函数参数为：", a)
	}(100)

}

func main() {
	// %d 表示整型数字，%s 表示字符串  %t 表示布尔值
	fmt.Println("Hello, World!")

	变量赋值()
	常量()
	deferMethod()
	go 匿名函数()
	fmt.Println("------------")
	time.Sleep(1 * time.Second)
	fmt.Println("------休眠5s-")
}
